package com.gxc.matrix;

import java.util.*;

/**
 * 现在有n个容器服务，服务的启动可能有一定的依赖性（有些服务启动没有依赖），其次服务自身启动加载会消耗一些时间。
 *
 * 给你一个 n x n 的二维矩阵useTime，其中
 *
 * useTime[i][i]=10 表示服务i自身启动加载需要消耗10s
 * useTime[i][j] = 1 表示服务i启动依赖服务j启动完成
 * useTime[i][k]=0 表示服务i启动不依赖服务k
 * 其实 0<= i，j，k < n。
 *
 * 服务之间启动没有循环依赖（不会出现环），若想对任意一个服务i进行集成测试（服务i自身也需要加载），求最少需要等待多少时间。
 *
 * 输入描述
 * 第一行输入服务总量 n，
 * 之后的 n 行表示服务启动的依赖关系以及自身启动加载耗时
 * 最后输入 k 表示计算需要等待多少时间后可以对服务 k 进行集成测试
 *
 * 其中 1 <= k <=n，1<=n<=100
 *
 * 输出描述
 * 最少需要等待多少时间(s)后可以对服务 k 进行集成测试
 */
public class MinUseTime {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[][] matrix = new int[n][n];

        Map<Integer, List<Integer>> relMap = new HashMap<>();
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                matrix[i][j] = scanner.nextInt();
                if (i != j && matrix[i][j] == 1) {
                    relMap.computeIfAbsent(i, k -> new ArrayList<>()).add(j);
                }
            }

        }
        int g = scanner.nextInt();
        scanner.close();

        System.out.println(DFS(matrix, relMap, g-1));
    }

    private static int DFS(int[][] matrix, Map<Integer, List<Integer>> relMap, int index) {
        int res = 0;
        List<Integer> relIds = relMap.getOrDefault(index, new ArrayList<>());
        for (Integer relId : relIds) {
            res = Math.max(res, DFS(matrix, relMap, relId));
        }
        res += matrix[index][index];
        return res;
    }

}
